#include "xor.h"
#include <string.h> // 用于memcpy
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
void xor_crypt_inplace(char *restrict data, size_t data_len, const char *restrict key, size_t key_len) {
    /* 安全检查 */
    if (!data || !key || key_len == 0) return;

    /* 特殊处理单字节密钥，消除循环开销 */
    if (key_len == 1) {
        const char k = key[0];
        for (size_t i = 0; i < data_len; ++i) {
            data[i] ^= k;
        }
        return;
    }

    /* 将小密钥复制到栈数组，提高缓存效率 */
    const char *key_ptr = key;
    char local_key[16]; // 根据常见密钥长度调整大小
    if (key_len <= sizeof(local_key)) {
        memcpy(local_key, key, key_len);
        key_ptr = local_key;
    }

    size_t key_index = 0;
    size_t i = 0;

    /* 分块处理：每次处理密钥剩余长度或剩余数据 */
    while (i < data_len) {
        size_t remaining_key = key_len - key_index;
        size_t block_size = (data_len - i < remaining_key) ? (data_len - i) : remaining_key;

        /* 手动循环展开：每次处理4字节（可根据平台调整） */
        size_t j = 0;
        for (; j + 3 < block_size; j += 4) {
            data[i + j]     ^= key_ptr[key_index + j];
            data[i + j + 1] ^= key_ptr[key_index + j + 1];
            data[i + j + 2] ^= key_ptr[key_index + j + 2];
            data[i + j + 3] ^= key_ptr[key_index + j + 3];
        }
        /* 处理剩余字节 */
        for (; j < block_size; ++j) {
            data[i + j] ^= key_ptr[key_index + j];
        }

        i += block_size;
        key_index += block_size;
        if (key_index >= key_len) {
            key_index -= key_len; // 减法替代取模
        }
    }
}

void xor_crypt(char *restrict output, const char *restrict input, size_t data_len,
              const char *restrict key, size_t key_len) {
    /* 安全检查 */
    if (!output || !input || !key || key_len == 0) return;

    /* 特殊处理单字节密钥 */
    if (key_len == 1) {
        const char k = key[0];
        for (size_t i = 0; i < data_len; ++i) {
            output[i] = input[i] ^ k;
        }
        return;
    }

    /* 局部密钥缓存 */
    const char *key_ptr = key;
    char local_key[16];
    if (key_len <= sizeof(local_key)) {
        memcpy(local_key, key, key_len);
        key_ptr = local_key;
    }

    size_t key_index = 0;
    size_t i = 0;

    while (i < data_len) {
        size_t remaining_key = key_len - key_index;
        size_t block_size = (data_len - i < remaining_key) ? (data_len - i) : remaining_key;

        /* 循环展开 */
        size_t j = 0;
        for (; j + 3 < block_size; j += 4) {
            output[i + j]     = input[i + j]     ^ key_ptr[key_index + j];
            output[i + j + 1] = input[i + j + 1] ^ key_ptr[key_index + j + 1];
            output[i + j + 2] = input[i + j + 2] ^ key_ptr[key_index + j + 2];
            output[i + j + 3] = input[i + j + 3] ^ key_ptr[key_index + j + 3];
        }
        for (; j < block_size; ++j) {
            output[i + j] = input[i + j] ^ key_ptr[key_index + j];
        }

        i += block_size;
        key_index += block_size;
        if (key_index >= key_len) {
            key_index -= key_len;
        }
    }
}


/**
 * 生成随机异或密钥（线程不安全的基础实现）
 * @param[out] key_len 接收生成的密钥实际长度
 * @return 动态分配的密钥缓冲区（必须用free释放），失败返回NULL
 * 
 * 特性：
 * 1. 包含大小写字母和数字（62种字符）
 * 2. 长度随机在8-16字节之间
 * 3. 缓冲区末尾自动添加\0（不影响实际密钥长度）
 * 
 * 注意：这个基础版本使用rand()，如需加密安全请替换随机源
 */
char* generate_xor_key(size_t* key_len) {
    const char charset[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                           "abcdefghijklmnopqrstuvwxyz"
                           "0123456789";
    const size_t charset_size = sizeof(charset) - 1;  // 62字符

    // 初始化伪随机数生成器（基础版本）
    static int seeded = 0;
    if (!seeded) {
        srand((unsigned int)time(NULL));
        seeded = 1;
    }

    // 生成随机长度 (8-16字节)
    size_t length = 8 + rand() % 9;
    char* key = malloc(length + 1);  // +1 用于终止符
    if (!key) return NULL;

    // 填充随机字符
    for (size_t i = 0; i < length; ++i) {
        key[i] = charset[rand() % charset_size];
    }
    key[length] = '\0';  // 添加终止符
    
    *key_len = length;
    return key;
}